home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / STRINGS / TS_STR / TS_STR.REF < prev    next >
Text File  |  1989-12-25  |  59KB  |  1,494 lines

  1.     -----------------------------------------------------------------------
  2.                    T U R B O   S T U F F   v 0 2 . 0 1 . 0 0
  3.     -----------------------------------------------------------------------
  4.     
  5.     
  6.     
  7.     
  8.     
  9.     
  10.     
  11.     
  12.     
  13.     
  14.     
  15.     
  16.     
  17.     
  18.     \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  19.     \\///////////////////////////////////////////////////////////////////\\
  20.     \\/////////////////      //  //  //      //      //      ////////////\\
  21.     \\//////////////////  ////  //  //  //  //  //  //  //  /////////////\\
  22.     \\/////////////////  ////  //  //      //     ///  //  //////////////\\
  23.     \\////////////////  ////  //  //  /  ///  //  //  //  ///////////////\\
  24.     \\///////////////  ////      //  //  //      //      ////////////////\\
  25.     \\///////////////////////////////////////////////////////////////////\\
  26.     \\///////////////////////////////////////////////////////////////////\\
  27.     \\/////////////////      //      //  //  //      //      ////////////\\
  28.     \\////////////////  ////////  ////  //  //  //////  /////////////////\\
  29.     \\///////////////      ////  ////  //  //     ///     ///////////////\\
  30.     \\//////////////////  ////  ////  //  //  //////  ///////////////////\\
  31.     \\/////////////      ////  ////      //  //////  ////////////////////\\
  32.     \\///////////////////////////////////////////////////////////////////\\
  33.     \\///////////////////////////////////////////////////////////////////\\
  34.     \\////////////      //      //////////      //      //      /////////\\
  35.     \\/////////////  ////  //////////////  ////////  ////  //  //////////\\
  36.     \\////////////  ////      //////////      ////  ////      ///////////\\
  37.     \\///////////  ////////  //////////////  ////  ////  /  /////////////\\
  38.     \\//////////  ////      //      //      ////  ////  //  /////////////\\
  39.     \\///////////////////////////////////////////////////////////////////\\
  40.     \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  41.     
  42.                             TS_STR Module Reference
  43.     
  44.     
  45.     
  46.     
  47.     
  48.     
  49.     
  50.     
  51.     
  52.     
  53.  
  54.     
  55.                            Shenandoah Valley Software
  56.                                  P.O. Box 1456
  57.                               Winchester, Va 22601
  58.                                   703-665-6491
  59.     
  60.     -----------------------------------------------------------------------
  61.     (C) Copyright 1989 by Shenandoah Valley Software -- All Rights Reserved
  62.     -----------------------------------------------------------------------
  63.  
  64.     TS_Str                   TURBO STUFF REFERENCE                 Page:  1
  65.     _______________________________________________________________________
  66.     
  67.  
  68.                        T A B L E   O F   C O N T E N T S
  69.                                 TS_STR Reference
  70.     
  71.  
  72.     For information on how to use the Turbo Stuff Toolbox,  please refer to 
  73.     the TS_STR.DOC file included in the archive. 
  74.  
  75.  
  76.       Ascii ..........................................................  2
  77.       AsciiZ .........................................................  3
  78.       ATrim ..........................................................  4
  79.       Center .........................................................  5
  80.       Change .........................................................  6
  81.       Compare ........................................................  7
  82.       DelCh ..........................................................  8
  83.       Decrypt ........................................................  9
  84.       Dup ............................................................ 10
  85.       DupStr ......................................................... 11
  86.       Encrypt ........................................................ 12
  87.       FirstLower ..................................................... 13
  88.       FirstUpper ..................................................... 14
  89.       Format ......................................................... 15
  90.       IIf ............................................................ 16
  91.       IsAlpha ........................................................ 17
  92.       IsLower ........................................................ 18
  93.       IsUpper ........................................................ 19
  94.       LFill .......................................................... 20
  95.       Left ........................................................... 21
  96.       LJust .......................................................... 22
  97.       LoCase ......................................................... 23
  98.       Lower .......................................................... 24
  99.       LTrim .......................................................... 25
  100.       Number ......................................................... 26
  101.       Proper ......................................................... 27
  102.       RFill .......................................................... 28
  103.       Right .......................................................... 29
  104.       RJust .......................................................... 30
  105.       Roman .......................................................... 31
  106.       RTrim .......................................................... 32
  107.       Same ........................................................... 33
  108.       SoundDif ....................................................... 34
  109.       SoundEx ........................................................ 35
  110.       Space .......................................................... 36
  111.       Stuff .......................................................... 37
  112.       Swap ........................................................... 38
  113.       Trim ........................................................... 39
  114.       Upper .......................................................... 40
  115.       Words .......................................................... 41
  116.  
  117.     TS_Str                   TURBO STUFF REFERENCE                 Page:  2
  118.     _______________________________________________________________________
  119.     
  120.     -----------------------------------------------------------------------
  121.     ASCII                                                          function
  122.     -----------------------------------------------------------------------
  123.     
  124.     Function       The ASCII function returns a string previously converted 
  125.                    to Asciiz back to its original format.
  126.  
  127.     Declaration    Ascii ( St:string )
  128.  
  129.     Result Type    String
  130.  
  131.     Remarks        The first byte of a Turbo Pascal string,  position  [0], 
  132.                    holds the actual length of the string. However, many DOS 
  133.                    services require Asciiz string.  The first byte of  this 
  134.                    string  type  actually holds the first character of  the 
  135.                    string,   while the last byte contains a Null (ASCII  0) 
  136.                    byte. 
  137.  
  138.                    The function is passed but one parameter,  (St),   which 
  139.                    contains the Asciiz string to be converted. 
  140.     
  141.     See Also       AsciiZ
  142.  
  143.     Source File    ASCII
  144.  
  145.     TS_Str                   TURBO STUFF REFERENCE                 Page:  3
  146.     _______________________________________________________________________
  147.     
  148.     -----------------------------------------------------------------------
  149.     ASCIIZ                                                         function
  150.     -----------------------------------------------------------------------
  151.     
  152.     Function       The  ASCIIZ  function converts a standard  Turbo  Pascal 
  153.                    string into a zero, or null, terminated string.
  154.  
  155.     Declaration    AsciiZ ( St:string )
  156.  
  157.     Result Type    String
  158.  
  159.     Remarks        The first byte of a Turbo Pascal string,  position  [0], 
  160.                    holds the actual length of the string. However, many DOS 
  161.                    services require Asciiz string.  The first byte of  this 
  162.                    string  type  actually holds the first character of  the 
  163.                    string,   while the last byte contains a Null (ASCII  0) 
  164.                    byte. 
  165.  
  166.                    The function is passed but one parameter,  (St),   which 
  167.                    contains the string to be converted.
  168.  
  169.                    Writing  Asciiz string may have  unpredictable  results. 
  170.                    Turbo  assumes  a  string to be printed  with  Write  or 
  171.                    Writeln  to have the length contained in the first byte. 
  172.                    Since  Asciiz  string have the first  character  of  the 
  173.                    string in this byte,  the result may be a string that is 
  174.                    too  short,  or may contain garbage characters following 
  175.                    it. In any case,  this function is primarily designed to 
  176.                    be  used with the various DOS services though the  MsDos 
  177.                    procedure (Turbo Pascal Reference Guide, page 334). 
  178.  
  179.     See Also       Ascii
  180.  
  181.     Source File    ASCII
  182.  
  183.     TS_Str                   TURBO STUFF REFERENCE                 Page:  4
  184.     _______________________________________________________________________
  185.     
  186.     -----------------------------------------------------------------------
  187.     ATRIM                                                          function
  188.     -----------------------------------------------------------------------
  189.     
  190.     Function       This function will return a string with a specific char-
  191.                    acter removed from the beginning and end of a string.
  192.  
  193.     Declaration    ATrim ( St:string; Ch:char )
  194.  
  195.     Result Type    String
  196.  
  197.     Remarks        This function is passed two parameters. The first, (St), 
  198.                    contains  the string that is to be trimmed.  The second, 
  199.                    (Ch), contains the character that is to be removed. 
  200.  
  201.     See Also       LTrim, RTrim, Trim
  202.  
  203.     Source File    ATRIM
  204.     
  205.     Example        VAR ST:STRING;
  206.  
  207.                    BEGIN
  208.                      ST := '***** THIS IS A TEST *****';
  209.                      WRITELN ( '>', ATRIM(ST,'*'), '<' );
  210.                    END.
  211.  
  212.  
  213.                    This produces the following result:
  214.  
  215.                    > THIS IS A TEST <
  216.    
  217.     TS_Str                   TURBO STUFF REFERENCE                 Page:  5
  218.     _______________________________________________________________________
  219.     
  220.     -----------------------------------------------------------------------
  221.     CENTER                                                         function
  222.     -----------------------------------------------------------------------
  223.     
  224.     Function       The CENTER function will return a string centered within 
  225.                    a specified field length.
  226.  
  227.     Declaration    Center ( St:string; Ch:char; Len:byte )
  228.  
  229.     Result Type    String
  230.  
  231.     Remarks        The first of three parameters required by this  function 
  232.                    is (St),  which contains the string to be centered.  The 
  233.                    second parameter, (Ch), is the character used to pad the 
  234.                    beginning  and end of the string within the field.   The 
  235.                    last, (Len), is the actual length of the field. 
  236.  
  237.     See Also       LJust, RJust
  238.  
  239.     Source File    CENTER
  240.     
  241.     Example        VAR ST:STRING;
  242.  
  243.                    BEGIN
  244.                      ST := ' THIS IS A TEST ';
  245.                      WRITELN ( '---------1---------2---------3---------' );
  246.                      WRITELN ( CENTER(ST,'*',30 );
  247.                    END.
  248.  
  249.  
  250.                    This produces the following result:
  251.  
  252.                    ---------1---------2---------3---------
  253.                    ******* THIS IS A TEST *******
  254.  
  255.     TS_Str                   TURBO STUFF REFERENCE                 Page:  6
  256.     _______________________________________________________________________
  257.     
  258.     -----------------------------------------------------------------------
  259.     CHANGE                                                         function
  260.     -----------------------------------------------------------------------
  261.     
  262.     Function       The function CHANGE, replace all occurances of a char-
  263.                    acter with another character.
  264.  
  265.     Declaration    Change ( St:string; Search,Replace:char )
  266.  
  267.     Result Type    String
  268.  
  269.     Remarks        This  function  will search the  entire  string  passed, 
  270.                    (St),   for the character specified in (Search).  Upon a 
  271.                    match, the character will be replaced with the one found 
  272.                    in (Replace). 
  273.  
  274.     See Also       DelCh
  275.  
  276.     Source File    CHANGE
  277.     
  278.     Example        VAR ST:STRING;
  279.  
  280.                    BEGIN
  281.                      ST := '***** THIS * IS * A * TEST *****';
  282.                      WRITELN ( CHANGE(ST,'*','-') );
  283.                    END.
  284.  
  285.  
  286.                    This produces the following result:
  287.  
  288.                    ----- THIS - IS - A - TEST -----
  289.  
  290.     TS_Str                   TURBO STUFF REFERENCE                 Page:  7
  291.     _______________________________________________________________________
  292.     
  293.     -----------------------------------------------------------------------
  294.     COMPARE                                                        function
  295.     -----------------------------------------------------------------------
  296.     
  297.     Function       This  function will compare two strings and return  TRUE 
  298.                    is they are the same. 
  299.  
  300.     Declaration    Compare ( St1,St2:string; UCase:boolean )
  301.  
  302.     Result Type    Boolean
  303.  
  304.     Remarks        This function can be either case sensitive,  or insensi-
  305.                    tive  depending on the status of the parameter  (UCase). 
  306.                    If true,  COMPARE will automatically convert the  string 
  307.                    to uppercase before testing. 
  308.  
  309.                    Obviously,  the other two parameters,  (St1)  and (St2), 
  310.                    are the string to be compared. 
  311.  
  312.     See Also       Same
  313.  
  314.     Source File    COMPARE
  315.     
  316.     Example        VAR ST1,ST2:STRING;
  317.  
  318.                    BEGIN
  319.                      ST1 := 'THIS IS A TEST';
  320.                      ST2 := 'this is a test';
  321.                      WRITELN ( COMPARE(ST1,ST2,TRUE) );
  322.                      WRITELN ( COMPARE(ST1,ST2,FALSE) );
  323.                    END.
  324.  
  325.  
  326.                    This produces the following result:
  327.  
  328.                    true
  329.                    false
  330.  
  331.     TS_Str                   TURBO STUFF REFERENCE                 Page:  8
  332.     _______________________________________________________________________
  333.     
  334.     -----------------------------------------------------------------------
  335.     DELCH                                                          function
  336.     -----------------------------------------------------------------------
  337.     
  338.     Function       The function DELCH, removes every occurance of the char-
  339.                    acter specified from a string.
  340.  
  341.     Declaration    DelCh ( St:string; Ch:char )
  342.  
  343.     Result Type    String
  344.  
  345.     Remarks        DelCh  will  remove every  character  found  within  the 
  346.                    string passed, (St), that matches the character in (Ch). 
  347.  
  348.     See Also       Change
  349.  
  350.     Source File    DELCH
  351.     
  352.     Example        VAR ST:STRING;
  353.  
  354.                    BEGIN
  355.                      ST := '***** THIS * IS * A * TEST *****';
  356.                      WRITELN ( DELCH(ST,'*') );
  357.                    END.
  358.  
  359.  
  360.                    This produces the following result:
  361.  
  362.                     THIS  IS  A  TEST
  363.  
  364.     TS_Str                   TURBO STUFF REFERENCE                 Page:  9
  365.     _______________________________________________________________________
  366.     
  367.     -----------------------------------------------------------------------
  368.     DECRYPT                                                        function
  369.     -----------------------------------------------------------------------
  370.     
  371.     Function       This  function decrypts a string that had be  previously 
  372.                    encrypted with the ENCRYPT function. 
  373.  
  374.     Declaration    Decrypt ( St:string )
  375.                     
  376.     Result Type    String
  377.  
  378.     Remarks        The  only parameter of this function is the string  that 
  379.                    had been previous encrypted. 
  380.  
  381.     See Also       Encrypt
  382.  
  383.     Source File    DECRYPT
  384.  
  385.     TS_Str                   TURBO STUFF REFERENCE                 Page: 10
  386.     _______________________________________________________________________
  387.     
  388.     -----------------------------------------------------------------------
  389.     DUP                                                            function
  390.     -----------------------------------------------------------------------
  391.     
  392.     Function       This  function DUPlicates a character a specific  number 
  393.                    of times and returns the result as a string. 
  394.  
  395.     Declaration    Dup ( Ch:char; Num:byte )
  396.  
  397.     Result Type    String
  398.  
  399.     Remarks        The character passed in (Ch)  is duplicated (Num)  times 
  400.                    before being returned. 
  401.  
  402.     See Also       DupStr, Space
  403.  
  404.     Source File    DUP
  405.     
  406.     Example        BEGIN
  407.                      WRITELN ( '---------1---------2---------3---------' );
  408.                      WRITELN ( DUP('*',30) );
  409.                    END.
  410.  
  411.  
  412.                    This produces the following result:
  413.  
  414.                    ---------1---------2---------3---------
  415.                    ******************************
  416.  
  417.     TS_Str                   TURBO STUFF REFERENCE                 Page: 11
  418.     _______________________________________________________________________
  419.     
  420.     -----------------------------------------------------------------------
  421.     DUPSTR                                                         function
  422.     -----------------------------------------------------------------------
  423.     
  424.     Function       This function is very similar to the DUP function except 
  425.                    that is duplicates a string for a specific length.
  426.  
  427.     Declaration    DupStr ( St:string; Len:byte )
  428.  
  429.     Result Type    String
  430.  
  431.     Remarks        The  string passed  as (St)  will be duplicated up to  a 
  432.                    maximum  length as specified in (Len).  If the length of 
  433.                    the string is so long as to make the final length longer 
  434.                    than (Len), the string will be truncated to (Len). 
  435.  
  436.     See Also       Dup
  437.  
  438.     Source File    DUPSTR
  439.     
  440.     Example        BEGIN
  441.                      WRITELN ( '---------1---------2---------3---------' );
  442.                      WRITELN ( DUPSTR('<**>',30) );
  443.                    END.
  444.  
  445.  
  446.                    This produces the following result:
  447.  
  448.                    ---------1---------2---------3---------
  449.                    <**><**><**><**><**><**><**><**><**><**
  450.  
  451.     TS_Str                   TURBO STUFF REFERENCE                 Page: 12
  452.     _______________________________________________________________________
  453.     
  454.     -----------------------------------------------------------------------
  455.     ENCRYPT                                                        function
  456.     -----------------------------------------------------------------------
  457.     
  458.     Function       The  function ENCRYPT will  encrypt a string so that  in 
  459.                    will be unreadable. 
  460.  
  461.     Declaration    Encrypt ( St:string )
  462.  
  463.     Result Type    String
  464.  
  465.     Remarks        This  single parameter  is obviously the  string  to  be 
  466.                    encrypted. 
  467.  
  468.                    The  encryption  scheme  is a  relatively  simple,   but 
  469.                    effective,  one.  Each character,  except the last,   is 
  470.                    XORed with the next character in the string.  The result 
  471.                    is  then  shifted left by one.  The  last  character  is 
  472.                    unaffected  and  is used as the starting point  for  the 
  473.                    DECRYPT function. 
  474.  
  475.     See Also       Decrypt
  476.  
  477.     Source File    DECRYPT
  478.  
  479.     TS_Str                   TURBO STUFF REFERENCE                 Page: 13
  480.     _______________________________________________________________________
  481.     
  482.     -----------------------------------------------------------------------
  483.     FIRSTLOWER                                                     function
  484.     -----------------------------------------------------------------------
  485.     
  486.     Function       This  function will return the first lowercase character 
  487.                    located within a string. 
  488.  
  489.     Declaration    FirstLower ( St:string )
  490.  
  491.     Result Type    String
  492.  
  493.     Remarks        This only parameter is the string to be searched.
  494.  
  495.     See Also       FirstUpper
  496.  
  497.     Source File    FLOWER
  498.     
  499.     Example        Is one really required?
  500.  
  501.     TS_Str                   TURBO STUFF REFERENCE                 Page: 14
  502.     _______________________________________________________________________
  503.     
  504.     -----------------------------------------------------------------------
  505.     FIRSTUPPER                                                     function
  506.     -----------------------------------------------------------------------
  507.     
  508.     Function       This  function will return the first uppercase character 
  509.                    located within a string. 
  510.  
  511.     Declaration    FirstUpper ( St:string )
  512.  
  513.     Result Type    String
  514.  
  515.     Remarks        This only parameter is the string to be searched.
  516.  
  517.     See Also       FirstLower
  518.  
  519.     Source File    FUPPER
  520.     
  521.     Example        Is one really required?
  522.  
  523.     TS_Str                   TURBO STUFF REFERENCE                 Page: 15
  524.     _______________________________________________________________________
  525.     
  526.     -----------------------------------------------------------------------
  527.     FORMAT                                                         function
  528.     -----------------------------------------------------------------------
  529.     
  530.     Function       FORMAT is a  simple string formatting procedure using  a 
  531.                    mask as defined by the user. 
  532.  
  533.     Declaration    Format ( St,Mask:string )
  534.  
  535.     Result Type    String
  536.  
  537.     Remarks        The string passed, (St),  will be formatted as specified 
  538.                    in the (Mask)  parameter.  Any character matching one of 
  539.                    those listed below will be interpreted as described. Any 
  540.                    character  NOT matching one below will be inserted  into 
  541.                    the string. Any character that is not valid for the mask 
  542.                    specified will be replaced with a blank space.
  543.  
  544.                      MASK     RESULT
  545.                      ----     --------------------------------------------
  546.                       *       Anything above ASCII 31 [32..255]
  547.  
  548.                       #       Number only, ['0'..'9']
  549.  
  550.                       ?       Letters only, ['A'..'Z','a'..'z']
  551.  
  552.                       &       As ?, with all lowercase characters being
  553.                               converted to uppercase
  554.  
  555.                       !       As *, with all lowercase characters being
  556.                               converted to uppercase
  557.  
  558.     See Also       Number
  559.  
  560.     Source File    FORMAT
  561.     
  562.     Example        BEGIN
  563.                      WRITELN( FORMAT('18005551212','#-###-###-####') );
  564.                      WRITELN( FORMAT('123456789','###-##-####') );
  565.                    END.
  566.  
  567.  
  568.                    This produces the following result:
  569.  
  570.                    1-800-555-1212
  571.                    123-45-6789
  572.  
  573.     TS_Str                   TURBO STUFF REFERENCE                 Page: 16
  574.     _______________________________________________________________________
  575.     
  576.     -----------------------------------------------------------------------
  577.     IIF                                                            function
  578.     -----------------------------------------------------------------------
  579.     
  580.     Function       This function stands for "Immediate If", and is meant as 
  581.                    a  short-cut replacement to the standard  IF..THEN..ELSE 
  582.                    process. 
  583.  
  584.     Declaration    IIF ( TF:boolean; St1,St2:string )
  585.  
  586.     Result Type    String
  587.  
  588.     Remarks        Depending on the condition passed as (TF),  the function 
  589.                    will return (St1)  if the condition is true or (St2)  if 
  590.                    false. 
  591.  
  592.     Source File    IIF
  593.     
  594.     Example        VAR SEX  :CHAR;
  595.                        LNAME:STRING;
  596.  
  597.                    BEGIN
  598.                      WRITE('ENTER YOUR LAST NAME: ');
  599.                      READLN(LNAME);
  600.                      WRITE('ENTER YOUR SEX: (M)ALE (F)EMALE: ');
  601.                      READLN(SEX);
  602.                      WRITELN;
  603.                      WRITELN ( IIF((SEX='M'),'MR. ','MS. '), LNAME );
  604.                    END.
  605.  
  606.  
  607.                    This  produces the following result:  (items in <>   are 
  608.                    user responses) 
  609.  
  610.                    ENTER YOUR LAST NAME: <COULTER>
  611.                    ENTER YOUR SEX: (M)ALE (F)EMALE: <M>
  612.  
  613.                    MR. COULTER
  614.  
  615.  
  616.                    Note:  if  the sex would have been  entered as <F>,  the 
  617.                    condition  passed (SEX='M')  would have been false,  and 
  618.                    thus the second string would have been returned instead. 
  619.  
  620.     TS_Str                   TURBO STUFF REFERENCE                 Page: 17
  621.     _______________________________________________________________________
  622.     
  623.     -----------------------------------------------------------------------
  624.     ISALPHA                                                        function
  625.     -----------------------------------------------------------------------
  626.     
  627.     Function       This  function  will  return TRUE is the  character  (or 
  628.                    string) passed contains only ABCs. 
  629.  
  630.     Declaration    IsAplha ( St:string )
  631.  
  632.     Result Type    Boolean
  633.  
  634.     Remarks        The string passed will be evaluated for contents of only 
  635.                    ['A'..'Z','a'..'z'].   Any  other character,   including 
  636.                    spaces, will cause the function to return false. 
  637.  
  638.                    Note:   This function is primarily intended to  be  used 
  639.                    with  single character but was designed to accept string 
  640.                    for greater flexibility. 
  641.  
  642.     See Also       IsLower, IsUpper
  643.  
  644.     Source File    ISALPHA
  645.  
  646.     TS_Str                   TURBO STUFF REFERENCE                 Page: 18
  647.     _______________________________________________________________________
  648.     
  649.     -----------------------------------------------------------------------
  650.     ISLOWER                                                        function
  651.     -----------------------------------------------------------------------
  652.     
  653.     Function       This  function will  return TRUE is  the  character  (or 
  654.                    string) passed contains only lowercase ABCs. 
  655.  
  656.     Declaration    IsLower ( St:string )
  657.  
  658.     Result Type    Boolean
  659.  
  660.     Remarks        The string passed will be evaluated for contents of only 
  661.                    ['a'..'z']. Any other character,  including spaces, will 
  662.                    cause the function to return false. 
  663.  
  664.                    Note:   This function is primarily intended to  be  used 
  665.                    with  single character but was designed to accept string 
  666.                    for greater flexibility. 
  667.  
  668.     See Also       IsAlpha, IsUpper
  669.  
  670.     Source File    ISLOWER
  671.  
  672.     TS_Str                   TURBO STUFF REFERENCE                 Page: 19
  673.     _______________________________________________________________________
  674.     
  675.     -----------------------------------------------------------------------
  676.     ISUPPER                                                        function
  677.     -----------------------------------------------------------------------
  678.     
  679.     Function       This  function will  return TRUE is  the  character  (or 
  680.                    string) passed contains only uppercase ABCs. 
  681.  
  682.     Declaration    IsUpper ( St:string )
  683.  
  684.     Result Type    Boolean
  685.  
  686.     Remarks        The string passed will be evaluated for contents of only 
  687.                    ['A'..'Z']. Any other character,  including spaces, will 
  688.                    cause the function to return false. 
  689.  
  690.                    Note:   This function is primarily intended to  be  used 
  691.                    with  single character but was designed to accept string 
  692.                    for greater flexibility. 
  693.  
  694.     See Also       IsAlpha, IsLower
  695.  
  696.     Source File    ISUPPER
  697.  
  698.     TS_Str                   TURBO STUFF REFERENCE                 Page: 20
  699.     _______________________________________________________________________
  700.     
  701.     -----------------------------------------------------------------------
  702.     LFILL                                                          function
  703.     -----------------------------------------------------------------------
  704.     
  705.     Function       This function will fill the left side of a string with a 
  706.                    character specified up to a maximum length.
  707.  
  708.     Declaration    LFill ( St:string; Ch:char; Len:byte )
  709.  
  710.     Result Type    String
  711.  
  712.     Remarks        The first of three parameters required by this  function 
  713.                    is  (St),  which contains the string to be filled.   The 
  714.                    second parameter, (Ch), is the character used to pad the 
  715.                    beginning  of  the string within the field.   The  last, 
  716.                    (Len), is the actual length of the field. 
  717.  
  718.     See Also       RFill
  719.  
  720.     Source File    LFILL
  721.     
  722.     Example        VAR ST:STRING;
  723.  
  724.                    BEGIN
  725.                      ST := ' THIS IS A TEST';
  726.                      WRITELN ( '---------1---------2---------3---------' );
  727.                      WRITELN ( LFILL(ST,'*',30) );
  728.                    END.
  729.  
  730.  
  731.                    This produces the following result:
  732.  
  733.                    ---------1---------2---------3---------
  734.                    ************************ THIS IS A TEST
  735.  
  736.     TS_Str                   TURBO STUFF REFERENCE                 Page: 21
  737.     _______________________________________________________________________
  738.     
  739.     -----------------------------------------------------------------------
  740.     LEFT                                                           function
  741.     -----------------------------------------------------------------------
  742.     
  743.     Function       The function LEFT will return only the leftmost  portion 
  744.                    of a string. 
  745.  
  746.     Declaration    Left ( St:string; Len:byte )
  747.  
  748.     Result Type    String
  749.  
  750.     Remarks        This  function will  returns a number of  characters  as 
  751.                    specified in (Len) from the left of the string (St). 
  752.  
  753.     See Also       Right
  754.  
  755.     Source File    LEFT
  756.     
  757.     Example        VAR ST:STRING;
  758.  
  759.                    BEGIN
  760.                      ST := 'THIS IS A TEST';
  761.                      WRITELN ( LEFT(ST,7) );
  762.                    END.
  763.  
  764.  
  765.                    This will produce the following result:
  766.  
  767.                    THIS IS
  768.  
  769.     TS_Str                   TURBO STUFF REFERENCE                 Page: 22
  770.     _______________________________________________________________________
  771.     
  772.     -----------------------------------------------------------------------
  773.     LJUST                                                          function
  774.     -----------------------------------------------------------------------
  775.     
  776.     Function       LJUST  will  left justify  a string within  a  field  of 
  777.                    spaces. 
  778.  
  779.     Declaration    LJust ( St:string; Len:byte )
  780.  
  781.     Result Type    String
  782.  
  783.     Remarks        The  string (St)  will have  trailing  spaces  added  to 
  784.                    justify it within the field lenght of (Len). 
  785.  
  786.     See Also       RJust
  787.  
  788.     Source File    LJUST
  789.                    
  790.     Example        VAR ST:STRING;
  791.  
  792.                    BEGIN
  793.                      ST := 'THIS IS A TEST';
  794.                      WRITELN ( '---------1---------2---------3---------' );
  795.                      WRITELN ( LJUST(ST,30), '<--' );
  796.                    END.
  797.  
  798.  
  799.                    This produces the following result:
  800.  
  801.                    ---------1---------2---------3---------
  802.                    THIS IS A TEST                <--
  803.  
  804.     TS_Str                   TURBO STUFF REFERENCE                 Page: 23
  805.     _______________________________________________________________________
  806.     
  807.     -----------------------------------------------------------------------
  808.     LOCASE                                                         function
  809.     -----------------------------------------------------------------------
  810.     
  811.     Function       This function is similar to the standard function UPCASE 
  812.                    as included with Turbo Pascal, but convert the character 
  813.                    to lowercase.
  814.  
  815.     Declaration    LoCase ( Ch:char ) : char;
  816.  
  817.     Result Type    Char
  818.  
  819.     Remarks        This function has only one parameter, (Ch), which is the 
  820.                    character to be converted. 
  821.  
  822.     See Also       Lower, Upper
  823.  
  824.     Source File    LOCASE
  825.  
  826.     TS_Str                   TURBO STUFF REFERENCE                 Page: 24
  827.     _______________________________________________________________________
  828.     
  829.     -----------------------------------------------------------------------
  830.     LOWER                                                          function
  831.     -----------------------------------------------------------------------
  832.     
  833.     Function       This function converts all uppercase characters within a 
  834.                    string to lowercase.
  835.  
  836.     Declaration    Lower ( St:string )
  837.  
  838.     Result Type    String
  839.  
  840.     Remarks        This single parameter (St) is the string to be converted 
  841.                    to lowercase. 
  842.  
  843.     See Also       LoCase, Proper, Upper
  844.  
  845.     Source File    LOWER
  846.  
  847.     TS_Str                   TURBO STUFF REFERENCE                 Page: 25
  848.     _______________________________________________________________________
  849.     
  850.     -----------------------------------------------------------------------
  851.     LTRIM                                                          function
  852.     -----------------------------------------------------------------------
  853.     
  854.     Function       This function will return a string with a specific char-
  855.                    acter removed from the beginning of a string.
  856.  
  857.     Declaration    LTrim ( St:string; Ch:char )
  858.  
  859.     Result Type    String
  860.  
  861.     Remarks        This function is passed two parameters. The first, (St), 
  862.                    contains  the string that is to be trimmed.  The second, 
  863.                    (Ch), contains the character that is to be removed. 
  864.  
  865.     See Also       ATrim, RTrim, Trim
  866.  
  867.     Source File    LTRIM
  868.     
  869.     Example        VAR ST:STRING;
  870.  
  871.                    BEGIN
  872.                      ST := '***** THIS IS A TEST *****';
  873.                      WRITELN ( '>', ATRIM(ST,'*'), '<' );
  874.                    END.
  875.  
  876.  
  877.                    This produces the following result:
  878.  
  879.                    > THIS IS A TEST *****<
  880.  
  881.     TS_Str                   TURBO STUFF REFERENCE                 Page: 26
  882.     _______________________________________________________________________
  883.     
  884.     -----------------------------------------------------------------------
  885.     NUMBER                                                         function
  886.     -----------------------------------------------------------------------
  887.     
  888.     Function       The  function NUMBER  will format a  number  (in  string 
  889.                    format) to a string with commas. 
  890.  
  891.     Declaration    Number ( St:string; Decimals:byte )
  892.  
  893.     Result Type    String
  894.  
  895.     Remarks        The number passed must be a string.  Use  the  standard 
  896.                    Turbo  Pascal function STR to convert number types to  a 
  897.                    string. 
  898.  
  899.                    The  number  passed is done so in (St).  The  number  of 
  900.                    digits to be included to the right of the decimal  point 
  901.                    is passed in (Decimals). 
  902.  
  903.                    This  function  has  special error  checking  facilities 
  904.                    built in.  Before any conversion is done,  it stips  all 
  905.                    non-numeric character from the string. 
  906.  
  907.     See Also       Format
  908.  
  909.     Source File    NUMBER
  910.     
  911.     Example        VAR ST:STRING;
  912.  
  913.                    BEGIN
  914.                      ST := '1234567890.12345';
  915.                      WRITELN ( NUMBER(ST,3):17 );
  916.                      ST := 'ASDF123456789LKJH';
  917.                      WRITELN ( NUMBER(ST,3):17 );
  918.                      ST := '111,222,333.444';
  919.                      WRITELN ( NUMBER(ST,3):17 );
  920.                    END.
  921.     
  922.     
  923.                    This produces the following result:
  924.  
  925.                    1,234,567,890.123
  926.                      123,456,789.000
  927.                      111,222,333.444
  928.  
  929.     TS_Str                   TURBO STUFF REFERENCE                 Page: 27
  930.     _______________________________________________________________________
  931.     
  932.     -----------------------------------------------------------------------
  933.     PROPER                                                         function
  934.     -----------------------------------------------------------------------
  935.     
  936.     Function       This function will return a string with the first letter 
  937.                    of each word converted to uppercase while all others are 
  938.                    converted to lowercase.
  939.  
  940.     Declaration    Proper ( St:string )
  941.  
  942.     Result Type    String
  943.  
  944.     Remarks        The only parameters is the string (St) to be converted.
  945.  
  946.     See Also       Lower, Upper
  947.  
  948.     Source File    PROPER
  949.     
  950.     Example        VAR ST:STRING;
  951.  
  952.                    BEGIN
  953.                      ST := 'JONATHAN W. COULTER';
  954.                      WRITELN ( PROPER(ST) );
  955.                    END.
  956.  
  957.  
  958.                    This produces the following result:
  959.  
  960.                    Jonathan W. Coulter
  961.  
  962.     TS_Str                   TURBO STUFF REFERENCE                 Page: 28
  963.     _______________________________________________________________________
  964.     
  965.     -----------------------------------------------------------------------
  966.     RFILL                                                          function
  967.     -----------------------------------------------------------------------
  968.     
  969.     Function       This  function will fill the right side of a string with 
  970.                    a character specified up to a maximum length. 
  971.  
  972.     Declaration    RFill ( St:string; Ch:char; Len:byte )
  973.  
  974.     Result Type    String
  975.  
  976.     Remarks        The first of three parameters required by this  function 
  977.                    is  (St),  which contains the string to be filled.   The 
  978.                    second parameter, (Ch), is the character used to pad the 
  979.                    end of the string within the field.  The last, (Len), is 
  980.                    the actual length of the field. 
  981.  
  982.     See Also       LFill
  983.  
  984.     Source File    RFILL
  985.     
  986.     Example        VAR ST:STRING;
  987.  
  988.                    BEGIN
  989.                      ST := 'THIS IS A TEST ';
  990.                      WRITELN ( '---------1---------2---------3---------' );
  991.                      WRITELN ( RFILL(ST,'*',30) );
  992.                    END.
  993.  
  994.  
  995.                    This produces the following result:
  996.  
  997.                    ---------1---------2---------3---------
  998.                    THIS IS A TEST ************************
  999.  
  1000.     TS_Str                   TURBO STUFF REFERENCE                 Page: 29
  1001.     _______________________________________________________________________
  1002.     
  1003.     -----------------------------------------------------------------------
  1004.     RIGHT                                                          function
  1005.     -----------------------------------------------------------------------
  1006.     
  1007.     Function       The function RIGHT  will return the rightmost portion of 
  1008.                    a string. 
  1009.  
  1010.     Declaration    Right ( St:string; Len:byte )
  1011.  
  1012.     Result Type    String
  1013.  
  1014.     Remarks        This  function will  returns a number of  characters  as 
  1015.                    specified in (Len) from the right of the string (St). 
  1016.  
  1017.     See Also       Left 
  1018.  
  1019.     Source File    RIGHT
  1020.     
  1021.     Example        VAR ST:STRING;
  1022.  
  1023.                    BEGIN
  1024.                      ST := 'THIS IS A TEST';
  1025.                      WRITELN ( RIGHT(ST,7) );
  1026.                    END.
  1027.  
  1028.  
  1029.                    This will produce the following result:
  1030.  
  1031.                     A TEST
  1032.  
  1033.     TS_Str                   TURBO STUFF REFERENCE                 Page: 30
  1034.     _______________________________________________________________________
  1035.     
  1036.     -----------------------------------------------------------------------
  1037.     RJUST                                                          function
  1038.     -----------------------------------------------------------------------
  1039.     
  1040.     Function       RJUST  will right justify  a string within  a  field  of 
  1041.                    spaces. 
  1042.  
  1043.     Declaration    RJust ( St:string; Len:byte )
  1044.  
  1045.     Result Type    String
  1046.  
  1047.     Remarks        The  string (St)  will  have  leading  spaces  added  to 
  1048.                    justify it within the field length of (Len). 
  1049.  
  1050.     See Also       LJust
  1051.  
  1052.     Source File    RJUST
  1053.                    
  1054.     Example        VAR ST:STRING;
  1055.  
  1056.                    BEGIN
  1057.                      ST := 'THIS IS A TEST';
  1058.                      WRITELN ( '---------1---------2---------3---------' );
  1059.                      WRITELN ( RJUST(ST,30) );
  1060.                    END.
  1061.  
  1062.  
  1063.                    This produces the following result:
  1064.  
  1065.                    ---------1---------2---------3---------
  1066.                                    THIS IS A TEST
  1067.  
  1068.     TS_Str                   TURBO STUFF REFERENCE                 Page: 31
  1069.     _______________________________________________________________________
  1070.     
  1071.     -----------------------------------------------------------------------
  1072.     ROMAN                                                          function
  1073.     -----------------------------------------------------------------------
  1074.     
  1075.     Function       The function ROMAN will convert any number,  up to 3999, 
  1076.                    to its equivalant Roman Numerial. 
  1077.  
  1078.     Declaration    Roman ( Num:integer )
  1079.  
  1080.     Result Type    String
  1081.  
  1082.     Remarks        The single parameter (Num) is the number to be converted 
  1083.                    to a roman numerial.
  1084.  
  1085.                    Note: the reason numbers above 3999 are not supported is 
  1086.                    the  fact that the PC can not duplicate those symbols in 
  1087.                    normal text mode. 
  1088.  
  1089.     Restrictions   Number greater than 3999 are not permitted.
  1090.  
  1091.     Source File    ROMAN
  1092.     
  1093.     Example        VAR I:INTEGER;
  1094.  
  1095.                    BEGIN
  1096.                      FOR I := 1 to 10 DO WRITELN ( ROMAN(I):4 );
  1097.                    END.
  1098.  
  1099.  
  1100.                    This produces the following result:
  1101.  
  1102.                       I
  1103.                      II
  1104.                     III
  1105.                      IV
  1106.                       V
  1107.                      VI
  1108.                     VII
  1109.                    VIII
  1110.                      IX
  1111.                       X
  1112.  
  1113.     TS_Str                   TURBO STUFF REFERENCE                 Page: 32
  1114.     _______________________________________________________________________
  1115.     
  1116.     -----------------------------------------------------------------------
  1117.     RTRIM                                                          function
  1118.     -----------------------------------------------------------------------
  1119.     
  1120.     Function       This function will return a string with a specific char-
  1121.                    acter removed from the end of a string.
  1122.  
  1123.     Declaration    RTrim ( St:string; Ch:char )
  1124.  
  1125.     Result Type    String
  1126.  
  1127.     Remarks        This function is passed two parameters. The first, (St), 
  1128.                    contains  the string that is to be trimmed.  The second, 
  1129.                    (Ch), contains the character that is to be removed. 
  1130.  
  1131.     See Also       ATrim, LTrim, Trim
  1132.  
  1133.     Source File    RTRIM
  1134.     
  1135.     Example        VAR ST:STRING;
  1136.  
  1137.                    BEGIN
  1138.                      ST := '***** THIS IS A TEST *****';
  1139.                      WRITELN ( '>', RTRIM(ST,'*'), '<' );
  1140.                    END.
  1141.  
  1142.  
  1143.                    This produces the following result:
  1144.  
  1145.                    >***** THIS IS A TEST <
  1146.  
  1147.     TS_Str                   TURBO STUFF REFERENCE                 Page: 33
  1148.     _______________________________________________________________________
  1149.     
  1150.     -----------------------------------------------------------------------
  1151.     SAME                                                           function
  1152.     -----------------------------------------------------------------------
  1153.     
  1154.     Function       The  function SAME will compare two strings  and  return 
  1155.                    whether or not the string match.  Wildcards are  allowed 
  1156.                    in the second string. 
  1157.  
  1158.     Declaration    Same ( St1,St2:string ) 
  1159.  
  1160.     Result Type    Boolean
  1161.  
  1162.     Remarks        Although  very similar  to the COMPARE  function,   this 
  1163.                    function does not alter the case before the comparision. 
  1164.                    However,   this function does have one luxury  that  the 
  1165.                    former  does not.  The second string passed can  contain 
  1166.                    any of the standard DOS wildcards. 
  1167.  
  1168.                    Upon  encountering  a  '?'  in the  second  string,   it 
  1169.                    corresponding  character in the first string is ignored. 
  1170.                    If  an '*'  is encountered,  the function  automatically 
  1171.                    returns  TRUE,  providing that all characters up to  the 
  1172.                    '*' have matched. 
  1173.  
  1174.     See Also       Compare
  1175.  
  1176.     Source File    SAME
  1177.     
  1178.     Example        BEGIN
  1179.                      WRITELN ( SAME('THIS IS A TEST','this is a test') );
  1180.                      WRITELN ( SAME('THIS IS A TEST','THIS IS*a test') );
  1181.                      WRITELN ( SAME('THIS IS A TEST','THIS IS ? TEST') );
  1182.                    END.
  1183.  
  1184.  
  1185.                    This produces the following result:
  1186.  
  1187.                    false
  1188.                    true
  1189.                    true
  1190.  
  1191.     TS_Str                   TURBO STUFF REFERENCE                 Page: 34
  1192.     _______________________________________________________________________
  1193.     
  1194.     -----------------------------------------------------------------------
  1195.     SOUNDDIF                                                       function
  1196.     -----------------------------------------------------------------------
  1197.     
  1198.     Function       This  functions returns a difference code computed  from 
  1199.                    two Soundex codes. 
  1200.  
  1201.     Declaration    SoundDif ( St1,St2:string )
  1202.  
  1203.     Result Type    Byte
  1204.  
  1205.     Remarks        The  two  paramters  passed must be four  digit  soundex 
  1206.                    codes. If either string is not, the result will be 4. 
  1207.  
  1208.                    The main advantage of this function is used in  database 
  1209.                    searches  or  spell checking.  If a incorrect  entry  is 
  1210.                    made,  all those with a SoundDif of 0 would be displayed 
  1211.                    to choose from. If none were found, or if a broader list 
  1212.                    is  desired,   those  with  a SoundDif  of  1  could  be 
  1213.                    displayed. 
  1214.  
  1215.     See Also       SoundEx
  1216.  
  1217.     Source File    SOUNDDIF
  1218.     
  1219.     Example        VAR ST1,ST2,ST3:STRING;
  1220.  
  1221.                    BEGIN
  1222.                      ST1 := 'COULTER';
  1223.                      ST2 := 'COLTER';
  1224.                      ST3 := 'KOULTER';
  1225.                      WRITELN ( SOUNDDIF(ST1,ST2) );
  1226.                      WRITELN ( SOUNDDIF(ST1,ST3) );
  1227.                    END.
  1228.  
  1229.  
  1230.                    This produces the following result:
  1231.  
  1232.                    0
  1233.                    1
  1234.  
  1235.     TS_Str                   TURBO STUFF REFERENCE                 Page: 35
  1236.     _______________________________________________________________________
  1237.     
  1238.     -----------------------------------------------------------------------
  1239.     SOUNDEX                                                        function
  1240.     -----------------------------------------------------------------------
  1241.     
  1242.     Function       The SOUNDEX function returns a phonetic match, or sound-
  1243.                    alike  code,  to facilitate finding a matching when  the 
  1244.                    exact spelling is not known. 
  1245.  
  1246.     Declaration    SoundEx ( St:string )
  1247.  
  1248.     Result Type    String
  1249.  
  1250.     Remarks        The SOUNDEX function returns a four-character code by 
  1251.                    using the following algorithm:
  1252.  
  1253.                    1) It retains the first character of the string (St) 
  1254.  
  1255.                    2) It drops all  occurrences of the letters: A E H I O U  
  1256.                       W and Y in all position except the first. 
  1257.  
  1258.                    3) All lower case letters are automatically converted to 
  1259.                       uppercase. 
  1260.  
  1261.                    4) It assigns a number to the remaining letters as shown 
  1262.                       in the below table: 
  1263.  
  1264.                                      B F P V           = 1
  1265.                                      C H J K Q S X Z   = 2
  1266.                                      D T               = 3
  1267.                                      L                 = 4
  1268.                                      M N               = 5
  1269.                                      R                 = 6
  1270.  
  1271.                    5) If two or more  adjacent letters have the same  code, 
  1272.                       it ignores all but the first letter found. 
  1273.  
  1274.                    6) It stops at the  first occurance of a non-alpha char-
  1275.                       acter. 
  1276.  
  1277.                    7) It returns a code in the form of A000.
  1278.  
  1279.                    8) It skips over leading blanks
  1280.  
  1281.                    9) It returns '0000' if the first non-blank character is 
  1282.                    not an alpha. 
  1283.  
  1284.     See Also       SoundDif
  1285.  
  1286.     Source File    SOUNDDEX
  1287.     
  1288.     Example        See the demonstration program for an example.
  1289.  
  1290.     TS_Str                   TURBO STUFF REFERENCE                 Page: 36
  1291.     _______________________________________________________________________
  1292.     
  1293.     -----------------------------------------------------------------------
  1294.     SPACE                                                          function
  1295.     -----------------------------------------------------------------------
  1296.     
  1297.     Function       This function returns a string of blank spaces.
  1298.  
  1299.     Declaration    Space ( Len:byte )
  1300.  
  1301.     Result Type    String
  1302.  
  1303.     Remarks        The only parameter required is the length (Len) of the 
  1304.                    string.
  1305.  
  1306.     See Also       Dup
  1307.  
  1308.     Source File    SPACE
  1309.     
  1310.     Example        BEGIN
  1311.                      WRITELN ( '->', SPACE(30), '<-' );
  1312.                    END.
  1313.  
  1314.  
  1315.                    This produces the following result:
  1316.  
  1317.                    ->                              <-
  1318.  
  1319.     TS_Str                   TURBO STUFF REFERENCE                 Page: 37
  1320.     _______________________________________________________________________
  1321.     
  1322.     -----------------------------------------------------------------------
  1323.     STUFF                                                          function
  1324.     -----------------------------------------------------------------------
  1325.     
  1326.     Function       The  function STUFF changes any part of a string without 
  1327.                    the need to reconstruct the entire string. 
  1328.  
  1329.     Declaration    Stuff ( St1,St2:string; Start,Del:byte )
  1330.  
  1331.     Result Type    String
  1332.  
  1333.     Remarks        The parameter (St1) is the original string that is to be 
  1334.                    altered  while (St2)  is the string to be inserted.  The 
  1335.                    start position is passed as (Start)  and indicates where 
  1336.                    you  want to begin the  replacemet.  Note that (St2)  is 
  1337.                    inserted  BEFORE the  position defined by  (Start).  The 
  1338.                    (Del)  parameter indicates how many characters you  want 
  1339.                    to remove from the original string. 
  1340.  
  1341.                    If (Del)  is zero,  (St2)  is simply inserted into (St1) 
  1342.                    and no characters are removed. 
  1343.  
  1344.                    If (Start) is zero, or is greater than the length of the 
  1345.                    original string (St1),  then (St2) will be tagged to the 
  1346.                    end of the original and (Del) will be ignored. 
  1347.  
  1348.                    If (St2)  is passed as a null string (i.e. '')  then the 
  1349.                    number of characters specified in (Del) will be removed. 
  1350.  
  1351.     Source File    STUFF
  1352.     
  1353.     Example        BEGIN
  1354.                      WRITELN ( STUFF('ABC','XYZ',2,1) );
  1355.                      WRITELN ( STUFF('ABC','',2,1) );
  1356.                      WRITELN ( STUFF('ABC','XYZ',2,0) );
  1357.                      WRITELN ( STUFF('ABC','XYZ',0,0) );
  1358.                    END.
  1359.  
  1360.  
  1361.                    This produces the following result:
  1362.  
  1363.                    AXYZC
  1364.                    AC
  1365.                    AXYZBC
  1366.                    ABCXYZ
  1367.  
  1368.     TS_Str                   TURBO STUFF REFERENCE                 Page: 38
  1369.     _______________________________________________________________________
  1370.     
  1371.     -----------------------------------------------------------------------
  1372.     SWAP                                                          procedure
  1373.     -----------------------------------------------------------------------
  1374.     
  1375.     Function       The  SWAP  function simply  swaps the  contents  of  two 
  1376.                    strings. 
  1377.  
  1378.     Declaration    Swap ( var St1,St2:string )
  1379.  
  1380.     Result Type    none
  1381.  
  1382.     Remarks        Swap will return the value of (St1)  in (St2)  and vice-
  1383.                    versa.  Note  that the actual length of the string  does 
  1384.                    not matter. 
  1385.  
  1386.     Source File    SWAP
  1387.                        
  1388.     Example        VAR ST1,ST2:string;
  1389.  
  1390.                    BEGIN
  1391.                      ST1 := 'THIS IS TEST STRING #1';
  1392.                      ST2 := 'THIS IS TEST #2';
  1393.                      WRITELN('BEFORE #1: ',ST1);
  1394.                      WRITELN('       #2: ',ST2);
  1395.                      SWAP(ST1,ST2);
  1396.                      WRITELN;
  1397.                      WRITELN('AFTER #1: ',ST1);
  1398.                      WRITELN('      #2: ',ST2);
  1399.                    END.
  1400.  
  1401.  
  1402.                    This produces the following result:
  1403.  
  1404.                    BEFORE #1: THIS IS TEST STRING #1
  1405.                           #2: THIS IS TEST #2
  1406.  
  1407.                    AFTER #1: THIS IS TEST #2
  1408.                          #2: THIS IS TEST STRING #1
  1409.  
  1410.     TS_Str                   TURBO STUFF REFERENCE                 Page: 39
  1411.     _______________________________________________________________________
  1412.     
  1413.     -----------------------------------------------------------------------
  1414.     TRIM                                                           function
  1415.     -----------------------------------------------------------------------
  1416.     
  1417.     Function       This function will return a string with all  leading and
  1418.                    trailing spaces removed from a string.
  1419.  
  1420.     Declaration    Trim ( St:string )
  1421.  
  1422.     Result Type    String
  1423.  
  1424.     Remarks        The only parameter passed is (St),  which is the  string 
  1425.                    to be trimmed. 
  1426.  
  1427.     See Also       ATrim, LTrim, RTrim
  1428.  
  1429.     Source File    TRIM
  1430.     
  1431.     Example        VAR ST:STRING;
  1432.  
  1433.                    BEGIN
  1434.                      ST := '      THIS IS A TEST      ';
  1435.                      WRITELN ( '>', TRIM(ST), '<' );
  1436.                    END.
  1437.  
  1438.  
  1439.                    This produces the following result:
  1440.                                    
  1441.                    >THIS IS A TEST<
  1442.  
  1443.     TS_Str                   TURBO STUFF REFERENCE                 Page: 40
  1444.     _______________________________________________________________________
  1445.     
  1446.     -----------------------------------------------------------------------
  1447.     UPPER                                                          function
  1448.     -----------------------------------------------------------------------
  1449.     
  1450.     Function       This function converts all lowercase characters within a 
  1451.                    string to uppercase.
  1452.  
  1453.     Declaration    Upper ( St:string )
  1454.  
  1455.     Result Type    String
  1456.  
  1457.     Remarks        This single parameter (St) is the string to be converted 
  1458.                    to uppercase. 
  1459.  
  1460.     See Also       LoCase, Lower, Proper
  1461.  
  1462.     Source File    UPPER
  1463.  
  1464.     TS_Str                   TURBO STUFF REFERENCE                 Page: 41
  1465.     _______________________________________________________________________
  1466.     
  1467.     -----------------------------------------------------------------------
  1468.     WORDS                                                          function
  1469.     -----------------------------------------------------------------------
  1470.     
  1471.     Function       The function WORDS returns the number of words contained 
  1472.                    within a string.
  1473.  
  1474.     Declaration    Words ( St:string )
  1475.  
  1476.     Result Type    Integer
  1477.  
  1478.     Remarks        The lone parameter is the string to be counted.
  1479.  
  1480.     Source File    WORDS
  1481.     
  1482.     Example        VAR ST:STRING;
  1483.  
  1484.                    BEGIN
  1485.                      ST := 'THIS IS TURBO STUFF! YEAAAAH!';
  1486.                      WRITELN ( 'THE NUMBER OF WORDS IS: ', WORDS(ST) );
  1487.                    END.
  1488.  
  1489.  
  1490.                    This produces the following result:
  1491.  
  1492.                    THE NUMBER OF WORDS IS: 5
  1493.  
  1494.